import 'dart:math' show Point;
// import 'dart:convert' show json;
// import 'package:flutter/services.dart' show rootBundle;

class Billing {
  // String dataFile;
  // String billType;
  List<Point<double>> points;
  double billAmount;

  Billing(this.points, this.billAmount);

  // Future<List<Point<double>>> jsonToPointList() async {
  //   Map<String, dynamic> data = json.decode(
  //     await rootBundle.loadString('assets/data/rate.json'),
  //   );
  //   List<dynamic> pointMap = data[billType] ?? [];
  //   return List.generate(
  //     pointMap.length,
  //     (i) => Point<double>(
  //       pointMap[i]['x'].toDouble(),
  //       pointMap[i]['y'].toDouble(),
  //     ),
  //   );
  // } // pointMap 假设结构为 {'index': num, 'x': num, 'y': num，'z': num}

  Point<double> linearInterpolate() {
    // List<Point<double>> points = await jsonToPointList();
    // 处理边界情况
    if (billAmount <= points.first.x) return points.first;
    if (billAmount >= points.last.x) return points.last;
    // 找到billAmount所在的线段
    int segmentIndex = 0;
    for (int i = 0; i < points.length - 1; i++) {
      if (billAmount >= points[i].x && billAmount <= points[i + 1].x) {
        segmentIndex = i;
        break;
      }
    }
    // 在线段上进行线性插值
    Point start = points[segmentIndex];
    Point end = points[segmentIndex + 1];
    double t = (billAmount - start.x) / (end.x - start.x);
    double y = start.y + t * (end.y - start.y);
    return Point(billAmount, y);
  }
}

/// 表示一个二维点
// class Point {
//   final double x;
//   final double y;

//   Point(this.x, this.y);

//   @override
//   String toString() => '($x, $y)';
// }

/// 该类用于从JSON文件中获取point数据
// class JsonPointFetcher {
//   /// 从指定路径的JSON文件中获取数据
//   static Future<List<Map<String, dynamic>>> getPointsFromJson(
//     String filePath,
//     String key,
//   ) async {
//     final String response = await rootBundle.loadString(filePath);
//     final Map<String, dynamic> data = json.decode(response);
//     final List<Map<String, dynamic>> points = List<Map<String, dynamic>>.from(
//       data[key] ?? [],
//     );
//     return points;
//   }
// }

// /// 折线插值器
// class PolylineInterpolator {
//   final List<Point> points;
//   final List<double> cumulativeLengths = [];
//   double totalLength = 0.0;

//   /// 构造函数，接受折线转折点列表
//   PolylineInterpolator(this.points) {
//     // 计算累积长度
//     if (points.length < 2) {
//       throw ArgumentError('至少需要两个点才能形成折线');
//     }

//     cumulativeLengths.add(0.0);
//     for (int i = 1; i < points.length; i++) {
//       final dx = points[i].x - points[i - 1].x;
//       final dy = points[i].y - points[i - 1].y;
//       final segmentLength = sqrt(dx * dx + dy * dy);
//       totalLength += segmentLength;
//       cumulativeLengths.add(totalLength);
//     }
//   }

//   /// 线性插值
//   Point linearInterpolate(double x) {
//     // 处理边界情况
//     if (x <= points.first.x) return points.first;
//     if (x >= points.last.x) return points.last;

//     // 找到x所在的线段
//     int segmentIndex = 0;
//     for (int i = 0; i < points.length - 1; i++) {
//       if (x >= points[i].x && x <= points[i + 1].x) {
//         segmentIndex = i;
//         break;
//       }
//     }

//     // 在线段上进行线性插值
//     final start = points[segmentIndex];
//     final end = points[segmentIndex + 1];
//     final t = (x - start.x) / (end.x - start.x);
//     final y = start.y + t * (end.y - start.y);

//     return Point(x, y);
//   }

  //   /// 按长度间隔取样
  //   List<Point> sampleByLength(double interval) {
  //     if (interval <= 0) throw ArgumentError('间隔必须大于0');

  //     final samples = <Point>[];
  //     double currentLength = 0.0;

  //     // 添加起点
  //     samples.add(points.first);

  //     while (currentLength < totalLength) {
  //       currentLength += interval;
  //       if (currentLength > totalLength) {
  //         samples.add(points.last);
  //         break;
  //       }

  //       // 找到当前长度对应的线段
  //       int segmentIndex = 0;
  //       for (int i = 0; i < cumulativeLengths.length - 1; i++) {
  //         if (currentLength >= cumulativeLengths[i] &&
  //             currentLength <= cumulativeLengths[i + 1]) {
  //           segmentIndex = i;
  //           break;
  //         }
  //       }

  //       // 在线段上进行插值
  //       final segmentStart = points[segmentIndex];
  //       final segmentEnd = points[segmentIndex + 1];
  //       final segmentLength =
  //           cumulativeLengths[segmentIndex + 1] - cumulativeLengths[segmentIndex];
  //       final t =
  //           (currentLength - cumulativeLengths[segmentIndex]) / segmentLength;

  //       final dx = segmentEnd.x - segmentStart.x;
  //       final dy = segmentEnd.y - segmentStart.y;
  //       final x = segmentStart.x + t * dx;
  //       final y = segmentStart.y + t * dy;

  //       samples.add(Point(x, y));
  //     }

  //     return samples;
  //   }

  //   /// 按X坐标间隔取样
  //   List<Point> sampleByX(double interval) {
  //     if (interval <= 0) throw ArgumentError('间隔必须大于0');

  //     final samples = <Point>[];
  //     final minX = points.first.x;
  //     final maxX = points.last.x;

  //     double currentX = minX;
  //     while (currentX <= maxX) {
  //       samples.add(linearInterpolate(currentX));
  //       currentX += interval;
  //     }

  //     // 确保包含终点
  //     if (samples.last.x < maxX) {
  //       samples.add(points.last);
  //     }

  //     return samples;
  //   }
  // }

  // void main() {
  //   // 测试数据：一个简单的折线
  //   final points = [
  //     Point(0, 0),
  //     Point(1, 1),
  //     Point(2, 0.5),
  //     Point(3, 1.5),
  //     Point(4, 0),
  //   ];

  //   // 创建插值器
  //   final interpolator = PolylineInterpolator(points);

  //   // 测试线性插值
  //   print('线性插值测试:');
  //   for (double x = 0; x <= 4; x += 0.5) {
  //     final point = interpolator.linearInterpolate(x);
  //     print('在 x=$x 处: $point');
  //   }

  //   // 测试按长度间隔取样
  //   print('\n按长度间隔取样 (间隔=1):');
  //   final lengthSamples = interpolator.sampleByLength(1.0);
  //   for (final point in lengthSamples) {
  //     print(point);
  //   }

  //   // 测试按X坐标间隔取样
  //   print('\n按X坐标间隔取样 (间隔=0.5):');
  //   final xSamples = interpolator.sampleByX(0.5);
  //   for (final point in xSamples) {
  //     print(point);
  //   }
// }
